home *** CD-ROM | disk | FTP | other *** search
/ Utilities Professional 1-1500 / Utilities Professional 1-1500 (1994)(WPD)[!].iso / 12511500 / var1432.dms / var1432.adf / NDUK-V40.lha / V40 / include / rexx / storage.h < prev    next >
C/C++ Source or Header  |  1993-10-15  |  9KB  |  234 lines
  1. #ifndef REXX_STORAGE_H
  2. #define REXX_STORAGE_H
  3. /*
  4. **    $VER: storage.h 1.4 (8.11.91)
  5. **    Includes Release 40.15
  6. **
  7. **    Header file to define ARexx data structures.
  8. **
  9. **    (C) Copyright 1986,1987,1988,1989,1990 William S. Hawes
  10. **    (C) Copyright 1990-1993 Commodore-Amiga, Inc.
  11. **        All Rights Reserved
  12. */
  13.  
  14. #ifndef EXEC_TYPES_H
  15. #include "exec/types.h"
  16. #endif
  17.  
  18. #ifndef EXEC_NODES_H
  19. #include "exec/nodes.h"
  20. #endif
  21.  
  22. #ifndef EXEC_LISTS_H
  23. #include "exec/lists.h"
  24. #endif
  25.  
  26. #ifndef EXEC_PORTS_H
  27. #include "exec/ports.h"
  28. #endif
  29.  
  30. #ifndef EXEC_LIBRARIES_H
  31. #include "exec/libraries.h"
  32. #endif
  33.  
  34. /* The NexxStr structure is used to maintain the internal strings in REXX.
  35.  * It includes the buffer area for the string and associated attributes.
  36.  * This is actually a variable-length structure; it is allocated for a
  37.  * specific length string, and the length is never modified thereafter
  38.  * (since it's used for recycling).
  39.  */
  40.  
  41. struct NexxStr {
  42.    LONG     ns_Ivalue;               /* integer value        */
  43.    UWORD    ns_Length;               /* length in bytes (excl null)    */
  44.    UBYTE    ns_Flags;               /* attribute flags        */
  45.    UBYTE    ns_Hash;               /* hash code            */
  46.    BYTE     ns_Buff[8];           /* buffer area for strings    */
  47.    };                       /* size: 16 bytes (minimum)    */
  48.  
  49. #define NXADDLEN 9               /* offset plus null byte    */
  50. #define IVALUE(nsPtr) (nsPtr->ns_Ivalue)
  51.  
  52. /* String attribute flag bit definitions                */
  53. #define NSB_KEEP     0               /* permanent string?        */
  54. #define NSB_STRING   1               /* string form valid?        */
  55. #define NSB_NOTNUM   2               /* non-numeric?            */
  56. #define NSB_NUMBER   3               /* a valid number?        */
  57. #define NSB_BINARY   4               /* integer value saved?        */
  58. #define NSB_FLOAT    5               /* floating point format?    */
  59. #define NSB_EXT      6               /* an external string?        */
  60. #define NSB_SOURCE   7               /* part of the program source?    */
  61.  
  62. /* The flag form of the string attributes                */
  63. #define NSF_KEEP     (1 << NSB_KEEP  )
  64. #define NSF_STRING   (1 << NSB_STRING)
  65. #define NSF_NOTNUM   (1 << NSB_NOTNUM)
  66. #define NSF_NUMBER   (1 << NSB_NUMBER)
  67. #define NSF_BINARY   (1 << NSB_BINARY)
  68. #define NSF_FLOAT    (1 << NSB_FLOAT )
  69. #define NSF_EXT      (1 << NSB_EXT   )
  70. #define NSF_SOURCE   (1 << NSB_SOURCE)
  71.  
  72. /* Combinations of flags                        */
  73. #define NSF_INTNUM   (NSF_NUMBER | NSF_BINARY | NSF_STRING)
  74. #define NSF_DPNUM    (NSF_NUMBER | NSF_FLOAT)
  75. #define NSF_ALPHA    (NSF_NOTNUM | NSF_STRING)
  76. #define NSF_OWNED    (NSF_SOURCE | NSF_EXT    | NSF_KEEP)
  77. #define KEEPSTR      (NSF_STRING | NSF_SOURCE | NSF_NOTNUM)
  78. #define KEEPNUM      (NSF_STRING | NSF_SOURCE | NSF_NUMBER | NSF_BINARY)
  79.  
  80. /* The RexxArg structure is identical to the NexxStr structure, but
  81.  * is allocated from system memory rather than from internal storage.
  82.  * This structure is used for passing arguments to external programs.
  83.  * It is usually passed as an "argstring", a pointer to the string buffer.
  84.  */
  85.  
  86. struct RexxArg {
  87.    LONG     ra_Size;               /* total allocated length    */
  88.    UWORD    ra_Length;               /* length of string        */
  89.    UBYTE    ra_Flags;               /* attribute flags        */
  90.    UBYTE    ra_Hash;               /* hash code            */
  91.    BYTE     ra_Buff[8];           /* buffer area            */
  92.    };                       /* size: 16 bytes (minimum)    */
  93.  
  94. /* The RexxMsg structure is used for all communications with REXX
  95.  * programs.  It is an EXEC message with a parameter block appended.
  96.  */
  97.  
  98. struct RexxMsg {
  99.    struct Message rm_Node;           /* EXEC message structure    */
  100.    APTR     rm_TaskBlock;           /* global structure (private)    */
  101.    APTR     rm_LibBase;           /* library base (private)    */
  102.    LONG     rm_Action;               /* command (action) code    */
  103.    LONG     rm_Result1;           /* primary result (return code)    */
  104.    LONG     rm_Result2;           /* secondary result        */
  105.    STRPTR   rm_Args[16];           /* argument block (ARG0-ARG15)    */
  106.  
  107.    struct MsgPort *rm_PassPort;        /* forwarding port        */
  108.    STRPTR   rm_CommAddr;           /* host address (port name)    */
  109.    STRPTR   rm_FileExt;           /* file extension        */
  110.    LONG     rm_Stdin;               /* input stream (filehandle)    */
  111.    LONG     rm_Stdout;               /* output stream (filehandle)    */
  112.    LONG     rm_avail;               /* future expansion        */
  113.    };                       /* size: 128 bytes        */
  114.  
  115. /* Field definitions                            */
  116. #define ARG0(rmp) (rmp->rm_Args[0])    /* start of argblock        */
  117. #define ARG1(rmp) (rmp->rm_Args[1])    /* first argument        */
  118. #define ARG2(rmp) (rmp->rm_Args[2])    /* second argument        */
  119.  
  120. #define MAXRMARG  15               /* maximum arguments        */
  121.  
  122. /* Command (action) codes for message packets                */
  123. #define RXCOMM      0x01000000           /* a command-level invocation    */
  124. #define RXFUNC      0x02000000           /* a function call        */
  125. #define RXCLOSE   0x03000000           /* close the REXX server    */
  126. #define RXQUERY   0x04000000           /* query for information    */
  127. #define RXADDFH   0x07000000           /* add a function host        */
  128. #define RXADDLIB  0x08000000           /* add a function library    */
  129. #define RXREMLIB  0x09000000           /* remove a function library    */
  130. #define RXADDCON  0x0A000000           /* add/update a ClipList string    */
  131. #define RXREMCON  0x0B000000           /* remove a ClipList string    */
  132. #define RXTCOPN   0x0C000000           /* open the trace console    */
  133. #define RXTCCLS   0x0D000000           /* close the trace console    */
  134.  
  135. /* Command modifier flag bits                        */
  136. #define RXFB_NOIO    16           /* suppress I/O inheritance?    */
  137. #define RXFB_RESULT  17           /* result string expected?    */
  138. #define RXFB_STRING  18           /* program is a "string file"?    */
  139. #define RXFB_TOKEN   19           /* tokenize the command line?    */
  140. #define RXFB_NONRET  20           /* a "no-return" message?    */
  141.  
  142. /* The flag form of the command modifiers                */
  143. #define RXFF_NOIO    (1L << RXFB_NOIO  )
  144. #define RXFF_RESULT  (1L << RXFB_RESULT)
  145. #define RXFF_STRING  (1L << RXFB_STRING)
  146. #define RXFF_TOKEN   (1L << RXFB_TOKEN )
  147. #define RXFF_NONRET  (1L << RXFB_NONRET)
  148.  
  149. #define RXCODEMASK   0xFF000000
  150. #define RXARGMASK    0x0000000F
  151.  
  152. /* The RexxRsrc structure is used to manage global resources.  Each node
  153.  * has a name string created as a RexxArg structure, and the total size
  154.  * of the node is saved in the "rr_Size" field.  The REXX systems library
  155.  * provides functions to allocate and release resource nodes.  If special
  156.  * deletion operations are required, an offset and base can be provided in
  157.  * "rr_Func" and "rr_Base", respectively.  This "autodelete" function will
  158.  * be called with the base in register A6 and the node in A0.
  159.  */
  160.  
  161. struct RexxRsrc {
  162.    struct Node rr_Node;
  163.    WORD     rr_Func;               /* "auto-delete" offset        */
  164.    APTR     rr_Base;               /* "auto-delete" base        */
  165.    LONG     rr_Size;               /* total size of node        */
  166.    LONG     rr_Arg1;               /* available ...        */
  167.    LONG     rr_Arg2;               /* available ...        */
  168.    };                       /* size: 32 bytes        */
  169.  
  170. /* Resource node types                            */
  171. #define RRT_ANY      0               /* any node type ...        */
  172. #define RRT_LIB      1               /* a function library        */
  173. #define RRT_PORT     2               /* a public port        */
  174. #define RRT_FILE     3               /* a file IoBuff        */
  175. #define RRT_HOST     4               /* a function host        */
  176. #define RRT_CLIP     5               /* a Clip List node        */
  177.  
  178. /* The RexxTask structure holds the fields used by REXX to communicate with
  179.  * external processes, including the client task.  It includes the global
  180.  * data structure (and the base environment).  The structure is passed to
  181.  * the newly-created task in its "wake-up" message.
  182.  */
  183.  
  184. #define GLOBALSZ  200               /* total size of GlobalData    */
  185.  
  186. struct RexxTask {
  187.    BYTE     rt_Global[GLOBALSZ];       /* global data structure    */
  188.    struct MsgPort rt_MsgPort;           /* global message port        */
  189.    UBYTE    rt_Flags;               /* task flag bits        */
  190.    BYTE     rt_SigBit;               /* signal bit            */
  191.  
  192.    APTR     rt_ClientID;           /* the client's task ID        */
  193.    APTR     rt_MsgPkt;               /* the packet being processed    */
  194.    APTR     rt_TaskID;               /* our task ID            */
  195.    APTR     rt_RexxPort;           /* the REXX public port        */
  196.  
  197.    APTR     rt_ErrTrap;           /* Error trap address        */
  198.    APTR     rt_StackPtr;           /* stack pointer for traps    */
  199.  
  200.    struct List rt_Header1;           /* Environment list        */
  201.    struct List rt_Header2;           /* Memory freelist        */
  202.    struct List rt_Header3;           /* Memory allocation list    */
  203.    struct List rt_Header4;           /* Files list            */
  204.    struct List rt_Header5;           /* Message Ports List        */
  205.    };
  206.  
  207. /* Definitions for RexxTask flag bits                    */
  208. #define RTFB_TRACE   0               /* external trace flag        */
  209. #define RTFB_HALT    1               /* external halt flag        */
  210. #define RTFB_SUSP    2               /* suspend task?        */
  211. #define RTFB_TCUSE   3               /* trace console in use?    */
  212. #define RTFB_WAIT    6               /* waiting for reply?        */
  213. #define RTFB_CLOSE   7               /* task completed?        */
  214.  
  215. /* Definitions for memory allocation constants                */
  216. #define MEMQUANT  16L               /* quantum of memory space    */
  217. #define MEMMASK   0xFFFFFFF0           /* mask for rounding the size    */
  218.  
  219. #define MEMQUICK  (1L << 0 )           /* EXEC flags: MEMF_PUBLIC    */
  220. #define MEMCLEAR  (1L << 16)           /* EXEC flags: MEMF_CLEAR    */
  221.  
  222. /* The SrcNode is a temporary structure used to hold values destined for
  223.  * a segment array.  It is also used to maintain the memory freelist.
  224.  */
  225.  
  226. struct SrcNode {
  227.    struct SrcNode *sn_Succ;           /* next node            */
  228.    struct SrcNode *sn_Pred;           /* previous node        */
  229.    APTR     sn_Ptr;               /* pointer value        */
  230.    LONG     sn_Size;               /* size of object        */
  231.    };                       /* size: 16 bytes        */
  232.  
  233. #endif
  234.